As data is transferred in a data processing system from a source location such as a Random Access Memory (RAM) buffer to a destiny location such as a disk drive disk, several errors can corrupt the addresses used in accessing the source and destiny locations. One such error is corruption of the address for accessing the source. In that case, the wrong data is read from the source. Another such error is corruption of the address of the destination. In that case, the data is written to the wrong location. In either scenario, the transferred data is lost, and a later attempt to retrieve the desired data from the destiny fails.
During a "write" operation, data is transferred from the source to the destiny, and during a "read" that data is read from the destiny back to the source. If during a write operation a corrupt source address remains undetected, then the wrong data is transferred to the destiny. And, when that data is read back, the wrong data is returned, and the intended data is lost. If the destination address is corrupt during the write operation, the data is written to the wrong location and lost. As a result, the desired data will not be found on a "read" back operation. As a side effect of writing the data to the wrong location in the destiny, the data pointed to by the corrupt address is written over, resulting loss of other good data.
Prior methods of solving such problems are directed to protecting the addresses used for accessing the source and the destiny by techniques such as parity checks. However, such methods are inefficient and error prone themselves. There is, therefore, a need for a method of preventing data transfers from using corrupt addresses.
There is also a need for such a method to be efficient and simple to implement.